ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷன்: ஜெனரேட்டர் செயின்களை உருவாக்குதல்

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன்கள் இட்டரபிள் தொடர்களை உருவாக்க ஒரு சக்திவாய்ந்த வழியை வழங்குகின்றன. அவை செயல்பாட்டை இடைநிறுத்தி மதிப்புகளை யீல்ட் செய்கின்றன, இது திறமையான மற்றும் நெகிழ்வான தரவு செயலாக்கத்தை அனுமதிக்கிறது. ஜெனரேட்டர்களின் மிகவும் சுவாரஸ்யமான திறன்களில் ஒன்று, அவற்றை ஒன்றாக இணைக்கும் திறன் ஆகும், இது சிக்கலான தரவு பைப்லைன்களை உருவாக்குகிறது. இந்த பதிவு ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷன் என்ற கருத்தை ஆழமாக ஆராய்ந்து, சிக்கலான பிரச்சனைகளைத் தீர்க்க ஜெனரேட்டர் செயின்களை உருவாக்குவதற்கான பல்வேறு நுட்பங்களை ஆராயும்.

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன்கள் என்றால் என்ன?

கம்போசிஷனுக்குள் செல்வதற்கு முன், ஜெனரேட்டர் ஃபங்ஷன்களை சுருக்கமாகப் பார்ப்போம். ஒரு ஜெனரேட்டர் ஃபங்ஷன் function* சிண்டாக்ஸ் பயன்படுத்தி வரையறுக்கப்படுகிறது. ஒரு ஜெனரேட்டர் ஃபங்ஷனுக்குள், yield என்ற கீவேர்டு செயல்பாட்டை இடைநிறுத்தி ஒரு மதிப்பைத் திருப்பப் பயன்படுகிறது. ஜெனரேட்டரின் next() மெத்தட் அழைக்கப்படும்போது, அடுத்த yield ஸ்டேட்மென்ட் அல்லது ஃபங்ஷனின் இறுதி வரை அது விட்ட இடத்திலிருந்து செயல்பாடு மீண்டும் தொடங்குகிறது.

இங்கே ஒரு எளிய உதாரணம்:

            
function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    yield i;
  }
}

const generator = numberGenerator(5);

console.log(generator.next()); // Output: { value: 0, done: false }
console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: 4, done: false }
console.log(generator.next()); // Output: { value: 5, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

இந்த ஜெனரேட்டர் ஃபங்ஷன் 0 முதல் ஒரு குறிப்பிட்ட அதிகபட்ச மதிப்பு வரையிலான எண்களை யீல்ட் செய்கிறது. next() மெத்தட் இரண்டு பண்புகளுடன் ஒரு ஆப்ஜெக்டைத் திருப்புகிறது: value (யீல்ட் செய்யப்பட்ட மதிப்பு) மற்றும் done (ஜெனரேட்டர் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்).

ஜெனரேட்டர் ஃபங்ஷன்களை ஏன் கம்போஸ் செய்ய வேண்டும்?

ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்வது, மாடுலர் மற்றும் மீண்டும் பயன்படுத்தக்கூடிய தரவு செயலாக்க பைப்லைன்களை உருவாக்க உங்களை அனுமதிக்கிறது. அனைத்து செயலாக்கப் படிகளையும் செய்யும் ஒரு ஒற்றை, மோனோலிதிக் ஜெனரேட்டரை எழுதுவதற்குப் பதிலாக, நீங்கள் சிக்கலை சிறிய, மேலும் நிர்வகிக்கக்கூடிய ஜெனரேட்டர்களாகப் பிரிக்கலாம், ஒவ்வொன்றும் ஒரு குறிப்பிட்ட பணிக்கு பொறுப்பாகும். இந்த ஜெனரேட்டர்களை பின்னர் ஒரு முழுமையான பைப்லைனை உருவாக்க ஒன்றாகச் இணைக்கலாம்.

கம்போசிஷனின் இந்த நன்மைகளைக் கவனியுங்கள்:

• மாடுலாரிட்டி: ஒவ்வொரு ஜெனரேட்டருக்கும் ஒரு ஒற்றை பொறுப்பு உள்ளது, இது கோடைப் புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்குகிறது.
• மறுபயன்பாடு: ஜெனரேட்டர்களை வெவ்வேறு பைப்லைன்களில் மீண்டும் பயன்படுத்தலாம், இது கோட் நகலெடுப்பைக் குறைக்கிறது.
• சோதனைத்திறன்: சிறிய ஜெனரேட்டர்களைத் தனித்தனியாகச் சோதிப்பது எளிது.
• நெகிழ்வுத்தன்மை: ஜெனரேட்டர்களைச் சேர்ப்பதன் மூலமோ, அகற்றுவதன் மூலமோ அல்லது மறுவரிசைப்படுத்துவதன் மூலமோ பைப்லைன்களை எளிதாக மாற்றியமைக்கலாம்.

ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்வதற்கான நுட்பங்கள்

ஜாவாஸ்கிரிப்ட்டில் ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்ய பல நுட்பங்கள் உள்ளன. மிகவும் பொதுவான சில அணுகுமுறைகளை ஆராய்வோம்.

1. ஜெனரேட்டர் டெலிகேஷன் (yield*)

yield* கீவேர்டு மற்றொரு இட்டரபிள் ஆப்ஜெக்டிற்கு, மற்றொரு ஜெனரேட்டர் ஃபங்ஷன் உட்பட, டெலிகேட் செய்ய ஒரு வசதியான வழியை வழங்குகிறது. yield* பயன்படுத்தப்படும்போது, டெலிகேட் செய்யப்பட்ட இட்டரபிள் யீல்ட் செய்யும் மதிப்புகள் நேரடியாக தற்போதைய ஜெனரேட்டரால் யீல்ட் செய்யப்படுகின்றன.

இரண்டு ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்ய yield* பயன்படுத்துவதற்கான ஒரு உதாரணம் இங்கே:

            
function* generateEvenNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 === 0) {
      yield i;
    }
  }
}

function* prependMessage(message, iterable) {
  yield message;
  yield* iterable;
}

const evenNumbers = generateEvenNumbers(10);
const messageGenerator = prependMessage("Even Numbers:", evenNumbers);

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// Even Numbers:
// 0
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், prependMessage ஒரு மெசேஜை யீல்ட் செய்து, பின்னர் yield* ஐப் பயன்படுத்தி generateEvenNumbers ஜெனரேட்டருக்கு டெலிகேட் செய்கிறது. இது இரண்டு ஜெனரேட்டர்களையும் திறம்பட ஒரு ஒற்றைத் தொடராக இணைக்கிறது.

2. மேனுவல் இட்டரேஷன் மற்றும் யீல்டிங்

டெலிகேட் செய்யப்பட்ட ஜெனரேட்டரை இட்டரேட் செய்து அதன் மதிப்புகளை யீல்ட் செய்வதன் மூலம் நீங்கள் ஜெனரேட்டர்களை மேனுவலாக கம்போஸ் செய்யலாம். இந்த அணுகுமுறை கம்போசிஷன் செயல்முறையின் மீது அதிக கட்டுப்பாட்டை வழங்குகிறது ஆனால் அதிக கோட் தேவைப்படுகிறது.

            
function* generateOddNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 !== 0) {
      yield i;
    }
  }
}

function* appendMessage(iterable, message) {
  for (const value of iterable) {
    yield value;
  }
  yield message;
}

const oddNumbers = generateOddNumbers(9);
const messageGenerator = appendMessage(oddNumbers, "End of Sequence");

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// 1
// 3
// 5
// 7
// 9
// End of Sequence

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், appendMessage ஆனது oddNumbers ஜெனரேட்டரை ஒரு for...of லூப்பைப் பயன்படுத்தி இட்டரேட் செய்து ஒவ்வொரு மதிப்பையும் யீல்ட் செய்கிறது. முழு ஜெனரேட்டரையும் இட்டரேட் செய்த பிறகு, அது இறுதி மெசேஜை யீல்ட் செய்கிறது.

3. ஹையர்-ஆர்டர் ஃபங்ஷன்களுடன் ஃபங்ஷனல் கம்போசிஷன்

ஜெனரேட்டர் கம்போசிஷனின் மிகவும் ஃபங்ஷனல் மற்றும் டெக்லரேடிவ் ஸ்டைலை உருவாக்க நீங்கள் ஹையர்-ஆர்டர் ஃபங்ஷன்களைப் பயன்படுத்தலாம். இது ஜெனரேட்டர்களை உள்ளீடாக எடுத்து, தரவு ஸ்ட்ரீமில் மாற்றங்களைச் செய்யும் புதிய ஜெனரேட்டர்களைத் திருப்பும் ஃபங்ஷன்களை உருவாக்குவதை உள்ளடக்கியது.

            
function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

function mapGenerator(generator, transform) {
  return function*() {
    for (const value of generator) {
      yield transform(value);
    }
  };
}

function filterGenerator(generator, predicate) {
  return function*() {
    for (const value of generator) {
      if (predicate(value)) {
        yield value;
      }
    }
  };
}

const numbers = numberRange(1, 10);
const squaredNumbers = mapGenerator(numbers, x => x * x)();
const evenSquaredNumbers = filterGenerator(squaredNumbers, x => x % 2 === 0)();

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், mapGenerator மற்றும் filterGenerator ஆகியவை ஒரு ஜெனரேட்டர் மற்றும் ஒரு டிரான்ஸ்ஃபார்மேஷன் அல்லது பிரடிகேட் ஃபங்ஷனை உள்ளீடாக எடுக்கும் ஹையர்-ஆர்டர் ஃபங்ஷன்களாகும். அவை அசல் ஜெனரேட்டரால் யீல்ட் செய்யப்பட்ட மதிப்புகளுக்கு டிரான்ஸ்ஃபார்மேஷன் அல்லது ஃபில்டரைப் பயன்படுத்தும் புதிய ஜெனரேட்டர் ஃபங்ஷன்களைத் திருப்புகின்றன. இந்த ஹையர்-ஆர்டர் ஃபங்ஷன்களை ஒன்றாக இணைப்பதன் மூலம் சிக்கலான பைப்லைன்களை உருவாக்க இது உங்களை அனுமதிக்கிறது.

4. ஜெனரேட்டர் பைப்லைன் லைப்ரரிகள் (எ.கா., IxJS)

பல ஜாவாஸ்கிரிப்ட் லைப்ரரிகள் இட்டரபிள்கள் மற்றும் ஜெனரேட்டர்களுடன் மிகவும் ஃபங்ஷனல் மற்றும் டெக்லரேடிவ் முறையில் வேலை செய்ய யூட்டிலிட்டிகளை வழங்குகின்றன. ஒரு உதாரணம் IxJS (Interactive Extensions for JavaScript), இது இட்டரபிள்களை மாற்றுவதற்கும் இணைப்பதற்கும் ஒரு வளமான ஆபரேட்டர்களின் தொகுப்பை வழங்குகிறது.

குறிப்பு: வெளிப்புற லைப்ரரிகளைப் பயன்படுத்துவது உங்கள் ப்ராஜெக்ட்டில் சார்புகளைச் சேர்க்கிறது. நன்மைகள் மற்றும் செலவுகளை மதிப்பீடு செய்யுங்கள்.

            
// Example using IxJS (install: npm install ix)
const { from, map, filter } = require('ix/iterable');

function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

const numbers = from(numberRange(1, 10));
const squaredNumbers = map(numbers, x => x * x);
const evenSquaredNumbers = filter(squaredNumbers, x => x % 2 === 0);

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு முந்தைய எடுத்துக்காட்டின் அதே மாற்றங்களைச் செய்ய IxJS ஐப் பயன்படுத்துகிறது, ஆனால் மிகவும் சுருக்கமான மற்றும் டெக்லரேடிவ் வழியில். IxJS இட்டரபிள்களில் செயல்படும் map மற்றும் filter போன்ற ஆபரேட்டர்களை வழங்குகிறது, இது சிக்கலான தரவு செயலாக்க பைப்லைன்களை உருவாக்குவதை எளிதாக்குகிறது.

ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷனின் நிஜ-உலக எடுத்துக்காட்டுகள்

ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷனை பல்வேறு நிஜ-உலக சூழ்நிலைகளில் பயன்படுத்தலாம். இங்கே சில எடுத்துக்காட்டுகள்:

1. தரவு மாற்றும் பைப்லைன்கள்

நீங்கள் ஒரு CSV கோப்பிலிருந்து தரவைச் செயலாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். பல்வேறு மாற்றங்களைச் செய்ய நீங்கள் ஜெனரேட்டர்களின் ஒரு பைப்லைனை உருவாக்கலாம், அவை:

• CSV கோப்பைப் படித்து ஒவ்வொரு வரிசையையும் ஒரு ஆப்ஜெக்டாக யீல்ட் செய்தல்.
• குறிப்பிட்ட அளவுகோல்களின் அடிப்படையில் வரிசைகளை வடிகட்டுதல் (எ.கா., ஒரு குறிப்பிட்ட நாட்டுக் குறியீட்டைக் கொண்ட வரிசைகள் மட்டும்).
• ஒவ்வொரு வரிசையிலும் உள்ள தரவை மாற்றுதல் (எ.கா., தேதிகளை ஒரு குறிப்பிட்ட வடிவத்திற்கு மாற்றுதல், கணக்கீடுகளைச் செய்தல்).
• மாற்றப்பட்ட தரவை ஒரு புதிய கோப்பு அல்லது தரவுத்தளத்தில் எழுதுதல்.

இந்த ஒவ்வொரு படியையும் ஒரு தனி ஜெனரேட்டர் ஃபங்ஷனாக செயல்படுத்தலாம், பின்னர் ஒரு முழுமையான தரவு செயலாக்க பைப்லைனை உருவாக்க ஒன்றாக இணைக்கலாம். உதாரணமாக, தரவு ஆதாரம் உலகளாவிய வாடிக்கையாளர் இருப்பிடங்களின் CSV ஆக இருந்தால், நாடு வாரியாக வடிகட்டுதல் (எ.கா., "ஜப்பான்", "பிரேசில்", "ஜெர்மனி") போன்ற படிகள் இருக்கலாம், பின்னர் ஒரு மத்திய அலுவலகத்திற்கான தூரங்களைக் கணக்கிடும் ஒரு மாற்றத்தைப் பயன்படுத்தலாம்.

2. அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்கள்

ஜெனரேட்டர்களை அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களைச் செயலாக்கவும் பயன்படுத்தலாம், அதாவது ஒரு வெப் சாக்கெட் அல்லது ஒரு API இலிருந்து வரும் தரவு. நீங்கள் ஸ்ட்ரீமிலிருந்து தரவைப் பெற்று, ஒவ்வொரு உருப்படியையும் அது கிடைக்கும்போது யீல்ட் செய்யும் ஒரு ஜெனரேட்டரை உருவாக்கலாம். இந்த ஜெனரேட்டரை பின்னர் தரவில் மாற்றங்கள் மற்றும் வடிகட்டல்களைச் செய்ய மற்ற ஜெனரேட்டர்களுடன் இணைக்கலாம்.

ஒரு பேஜினேட்டட் API இலிருந்து பயனர் சுயவிவரங்களைப் பெறுவதைக் கவனியுங்கள். ஒரு ஜெனரேட்டர் ஒவ்வொரு பக்கத்தையும் பெற்று, அந்தப் பக்கத்திலிருந்து பயனர் சுயவிவரங்களை yield* செய்யலாம். மற்றொரு ஜெனரேட்டர் கடந்த மாதத்திற்குள் செயல்பாட்டின் அடிப்படையில் இந்த சுயவிவரங்களை வடிகட்டலாம்.

3. தனிப்பயன் இட்டரேட்டர்களை செயல்படுத்துதல்

ஜெனரேட்டர் ஃபங்ஷன்கள் சிக்கலான தரவுக் கட்டமைப்புகளுக்கு தனிப்பயன் இட்டரேட்டர்களை செயல்படுத்த ஒரு சுருக்கமான வழியை வழங்குகின்றன. நீங்கள் தரவுக் கட்டமைப்பை கடந்து அதன் கூறுகளை ஒரு குறிப்பிட்ட வரிசையில் யீல்ட் செய்யும் ஒரு ஜெனரேட்டரை உருவாக்கலாம். இந்த இட்டரேட்டரை பின்னர் for...of லூப்கள் அல்லது பிற இட்டரபிள் சூழல்களில் பயன்படுத்தலாம்.

எடுத்துக்காட்டாக, ஒரு பைனரி மரத்தை ஒரு குறிப்பிட்ட வரிசையில் (எ.கா., இன்-ஆர்டர், ப்ரீ-ஆர்டர், போஸ்ட்-ஆர்டர்) கடக்கும் ஒரு ஜெனரேட்டரை உருவாக்கலாம் அல்லது ஒரு விரிதாளின் செல்களில் வரிசை வாரியாக இட்டரேட் செய்யலாம்.

ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷனுக்கான சிறந்த நடைமுறைகள்

ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்யும்போது மனதில் கொள்ள வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• ஜெனரேட்டர்களை சிறியதாகவும் கவனம் செலுத்துவதாகவும் வைத்திருங்கள்: ஒவ்வொரு ஜெனரேட்டருக்கும் ஒரு ஒற்றை, நன்கு வரையறுக்கப்பட்ட பொறுப்பு இருக்க வேண்டும். இது கோடைப் புரிந்துகொள்வதற்கும், சோதிப்பதற்கும், பராமரிப்பதற்கும் எளிதாக்குகிறது.
• விளக்கமான பெயர்களைப் பயன்படுத்துங்கள்: உங்கள் ஜெனரேட்டர்களுக்கு அவற்றின் நோக்கத்தைத் தெளிவாகக் குறிக்கும் விளக்கமான பெயர்களைக் கொடுங்கள்.
• பிழைகளை நளினமாகக் கையாளுங்கள்: பைப்லைன் வழியாக பிழைகள் பரவுவதைத் தடுக்க ஒவ்வொரு ஜெனரேட்டரிலும் பிழை கையாளுதலைச் செயல்படுத்தவும். உங்கள் ஜெனரேட்டர்களுக்குள் try...catch பிளாக்குகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• செயல்திறனைக் கருத்தில் கொள்ளுங்கள்: ஜெனரேட்டர்கள் பொதுவாக திறமையானவை என்றாலும், சிக்கலான பைப்லைன்கள் செயல்திறனை பாதிக்கலாம். உங்கள் கோடை சுயவிவரப்படுத்தி, தேவைப்படும் இடங்களில் மேம்படுத்தவும்.
• உங்கள் கோடை ஆவணப்படுத்துங்கள்: ஒவ்வொரு ஜெனரேட்டரின் நோக்கத்தையும், அது பைப்லைனில் உள்ள மற்ற ஜெனரேட்டர்களுடன் எவ்வாறு தொடர்பு கொள்கிறது என்பதையும் தெளிவாக ஆவணப்படுத்துங்கள்.

மேம்பட்ட நுட்பங்கள்

ஜெனரேட்டர் செயின்களில் பிழை கையாளுதல்

ஜெனரேட்டர் செயின்களில் பிழைகளைக் கையாளுவதற்கு கவனமான பரிசீலனை தேவை. ஒரு ஜெனரேட்டருக்குள் ஒரு பிழை ஏற்படும்போது, அது முழு பைப்லைனையும் சீர்குலைக்கக்கூடும். நீங்கள் பயன்படுத்தக்கூடிய சில உத்திகள் உள்ளன:

1. ஜெனரேட்டர்களுக்குள் Try-Catch: மிகவும் நேரடியான அணுகுமுறை ஒவ்வொரு ஜெனரேட்டர் ஃபங்ஷனுக்குள் உள்ள கோடை ஒரு try...catch பிளாக்கில் வைப்பதாகும். இது பிழைகளை உள்நாட்டில் கையாளவும், ஒரு இயல்புநிலை மதிப்பு அல்லது ஒரு குறிப்பிட்ட பிழை ஆப்ஜெக்டை யீல்ட் செய்யவும் உங்களை அனுமதிக்கிறது.
2. பிழை எல்லைகள் (ரியாக்டிலிருந்து ஒரு கருத்து, இங்கே மாற்றியமைக்கக்கூடியது): அதன் டெலிகேட் செய்யப்பட்ட ஜெனரேட்டரால் வீசப்படும் எந்த விதிவிலக்குகளையும் பிடிக்கும் ஒரு ராப்பர் ஜெனரேட்டரை உருவாக்கவும். இது பிழையைப் பதிவு செய்யவும், ஒரு ஃபால்பேக் மதிப்புடன் செயினை மீண்டும் தொடங்கவும் உங்களை அனுமதிக்கிறது.

            
function* potentiallyFailingGenerator() {
  try {
    // Code that might throw an error
    const result = someRiskyOperation();
    yield result;
  } catch (error) {
    console.error("Error in potentiallyFailingGenerator:", error);
    yield null; // Or yield a specific error object
  }
}

function* errorBoundary(generator) {
    try {
        yield* generator();
    } catch (error) {
        console.error("Error Boundary Caught:", error);
        yield "Fallback Value"; // Or some other recovery mechanism
    }
}

const myGenerator = errorBoundary(potentiallyFailingGenerator);

for (const value of myGenerator) {
  console.log(value);
}

            

              
                Copy
              
            
          

அசிங்க்ரோனஸ் ஜெனரேட்டர்கள் மற்றும் கம்போசிஷன்

ஜாவாஸ்கிரிப்ட்டில் அசிங்க்ரோனஸ் ஜெனரேட்டர்களின் அறிமுகத்துடன், நீங்கள் இப்போது அசிங்க்ரோனஸ் தரவை மிகவும் இயல்பாகச் செயலாக்கும் ஜெனரேட்டர் செயின்களை உருவாக்கலாம். அசிங்க்ரோனஸ் ஜெனரேட்டர்கள் async function* சிண்டாக்ஸைப் பயன்படுத்துகின்றன மற்றும் அசிங்க்ரோனஸ் செயல்பாடுகளுக்காகக் காத்திருக்க await கீவேர்டைப் பயன்படுத்தலாம்.

            
async function* fetchUsers(userIds) {
  for (const userId of userIds) {
    const user = await fetchUser(userId); // Assuming fetchUser is an async function
    yield user;
  }
}

async function* filterActiveUsers(users) {
  for await (const user of users) {
    if (user.isActive) {
      yield user;
    }
  }
}

async function fetchUser(id) {
    //Simulate an async fetch
    return new Promise(resolve => {
        setTimeout(() => {
            resolve({ id: id, name: `User ${id}`, isActive: id % 2 === 0});
        }, 500);
    });
}

async function main() {
  const userIds = [1, 2, 3, 4, 5];
  const users = fetchUsers(userIds);
  const activeUsers = filterActiveUsers(users);

  for await (const user of activeUsers) {
    console.log(user);
  }
}

main();

//Possible output:
// { id: 2, name: 'User 2', isActive: true }
// { id: 4, name: 'User 4', isActive: true }

            

              
                Copy
              
            
          

அசிங்க்ரோனஸ் ஜெனரேட்டர்களை இட்டரேட் செய்ய, நீங்கள் ஒரு for await...of லூப்பைப் பயன்படுத்த வேண்டும். அசிங்க்ரோனஸ் ஜெனரேட்டர்களை சாதாரண ஜெனரேட்டர்களைப் போலவே yield* ஐப் பயன்படுத்தி கம்போஸ் செய்யலாம்.

முடிவுரை

ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷன் என்பது ஜாவாஸ்கிரிப்ட்டில் மாடுலர், மீண்டும் பயன்படுத்தக்கூடிய, மற்றும் சோதிக்கக்கூடிய தரவு செயலாக்க பைப்லைன்களை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த நுட்பமாகும். சிக்கலான பிரச்சனைகளை சிறிய, நிர்வகிக்கக்கூடிய ஜெனரேட்டர்களாகப் பிரிப்பதன் மூலம், நீங்கள் மேலும் பராமரிக்கக்கூடிய மற்றும் நெகிழ்வான கோடை உருவாக்கலாம். நீங்கள் ஒரு CSV கோப்பிலிருந்து தரவை மாற்றினாலும், அசிங்க்ரோனஸ் தரவு ஸ்ட்ரீம்களைச் செயலாக்கினாலும், அல்லது தனிப்பயன் இட்டரேட்டர்களை செயல்படுத்தினாலும், ஜெனரேட்டர் ஃபங்ஷன் கம்போசிஷன் நீங்கள் தூய்மையான மற்றும் திறமையான கோடை எழுத உதவும். ஜெனரேட்டர் டெலிகேஷன், மேனுவல் இட்டரேஷன், மற்றும் ஹையர்-ஆர்டர் ஃபங்ஷன்களுடன் ஃபங்ஷனல் கம்போசிஷன் உள்ளிட்ட ஜெனரேட்டர் ஃபங்ஷன்களை கம்போஸ் செய்வதற்கான வெவ்வேறு நுட்பங்களைப் புரிந்துகொள்வதன் மூலம், உங்கள் ஜாவாஸ்கிரிப்ட் ப்ராஜெக்ட்களில் ஜெனரேட்டர்களின் முழு திறனையும் நீங்கள் பயன்படுத்தலாம். சிறந்த நடைமுறைகளைப் பின்பற்றவும், பிழைகளை நளினமாகக் கையாளவும், உங்கள் ஜெனரேட்டர் பைப்லைன்களை வடிவமைக்கும்போது செயல்திறனைக் கருத்தில் கொள்ளவும் நினைவில் கொள்ளுங்கள். வெவ்வேறு அணுகுமுறைகளுடன் பரிசோதனை செய்து, உங்கள் தேவைகளுக்கும் கோடிங் ஸ்டைலுக்கும் மிகவும் பொருத்தமான நுட்பங்களைக் கண்டறியுங்கள். இறுதியாக, உங்கள் ஜெனரேட்டர் அடிப்படையிலான பணிப்பாய்வுகளை மேலும் மேம்படுத்த IxJS போன்ற ஏற்கனவே உள்ள லைப்ரரிகளை ஆராயுங்கள். பயிற்சியுடன், ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன்களைப் பயன்படுத்தி நீங்கள் அதிநவீன மற்றும் திறமையான தரவு செயலாக்க தீர்வுகளை உருவாக்க முடியும்.